home *** CD-ROM | disk | FTP | other *** search
/ Aminet 15 / Aminet 15 - Nov 1996.iso / Aminet / dev / lang / FPL_v147.lha / fpl / src / scan.c < prev    next >
C/C++ Source or Header  |  1996-05-28  |  12KB  |  405 lines
  1. /******************************************************************************
  2.  *                   FREXX PROGRAMMING LANGUAGE                  *
  3.  ******************************************************************************
  4.  
  5.  scan.c
  6.  
  7.  Various program scanning/reading routines.
  8.  
  9.  *****************************************************************************/
  10.  
  11. /************************************************************************
  12.  *                                                                      *
  13.  * fpl.library - A shared library interpreting script langauge.         *
  14.  * Copyright (C) 1992-1994 FrexxWare                                    *
  15.  * Author: Daniel Stenberg                                              *
  16.  *                                                                      *
  17.  * This program is free software; you may redistribute for non          *
  18.  * commercial purposes only. Commercial programs must have a written    *
  19.  * permission from the author to use FPL. FPL is *NOT* public domain!   *
  20.  * Any provided source code is only for reference and for assurance     *
  21.  * that users should be able to compile FPL on any operating system     *
  22.  * he/she wants to use it in!                                           *
  23.  *                                                                      *
  24.  * You may not change, resource, patch files or in any way reverse      *
  25.  * engineer anything in the FPL package.                                *
  26.  *                                                                      *
  27.  * This program is distributed in the hope that it will be useful,      *
  28.  * but WITHOUT ANY WARRANTY; without even the implied warranty of       *
  29.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                 *
  30.  *                                                                      *
  31.  * Daniel Stenberg                                                      *
  32.  * Ankdammsgatan 36, 4tr                                                *
  33.  * S-171 43 Solna                                                       *
  34.  * Sweden                                                               *
  35.  *                                                                      *
  36.  * FidoNet 2:201/328    email:dast@sth.frontec.se                       *
  37.  *                                                                      *
  38.  ************************************************************************/
  39.  
  40. #ifdef AMIGA
  41. #include <exec/types.h>
  42. #include <dos.h>
  43.  
  44. #elif defined(UNIX)
  45. #include <sys/types.h>
  46. #include <stdio.h>
  47. #endif
  48.  
  49. #include "script.h"
  50. #include "debug.h"
  51.  
  52. static ReturnCode INLINE Eatcomment(struct Data *);
  53.  
  54. /************************************************************************
  55.  *
  56.  * int GetEnd(struct Data *, uchar, uchar, uchar)
  57.  *
  58.  * Makes the current position to be the one right after the character
  59.  * you wanna search for.
  60.  *
  61.  * Returns error code.
  62.  *
  63.  *****/
  64.  
  65. ReturnCode REGARGS
  66. GetEnd(struct Data *scr, /* giant script structure */
  67.        uchar leta,     /* what character you do wanna find */
  68.        uchar motsats,     /* the opposite character do the one above */
  69.        uchar outside)     /* TRUE/FALSE if outside an opposite version */
  70. {
  71.   ReturnCode ret;
  72.   uchar find=1-outside;
  73.   long junk; /* only for the ReturnChar() function */
  74.   long prg=scr->prg;
  75.   uchar *text=scr->text;
  76.   uchar check;
  77.   while(scr->prg<=scr->prog->lines) {
  78.     check=*scr->text;
  79.     if(check==leta) {
  80.       scr->text++;
  81.       if(!--find)
  82.     return(FPL_OK);
  83.     } else if(check==motsats) {
  84.       find++;
  85.       scr->text++;
  86.     } else if(check==CHAR_QUOTATION_MARK) {
  87.       scr->text++;
  88.       if(GetEnd(scr, CHAR_QUOTATION_MARK, (uchar)255, FALSE))
  89.     return(FPLERR_SYNTAX_ERROR); /* missing quotation mark */
  90.     } else if(check==CHAR_APOSTROPHE && leta!=CHAR_QUOTATION_MARK) {
  91.       scr->text++;
  92.       CALL(ReturnChar(scr, &junk, FALSE));
  93.       if(CHAR_APOSTROPHE!=*scr->text++)
  94.     return(FPLERR_MISSING_APOSTROPHE);
  95.     } else if(check==CHAR_ASCII_ZERO) {
  96.       CALL(Newline(scr));
  97.     } else if(leta==CHAR_QUOTATION_MARK && check == CHAR_BACKSLASH) {
  98.       CALL(ReturnChar(scr, &junk, TRUE));
  99.     } else {
  100.       if(check==CHAR_NEWLINE)
  101.     scr->virprg++;
  102.       scr->text++;
  103.       if(leta!=CHAR_QUOTATION_MARK && Eat(scr))
  104.         /* we only call Eat() if this is *not* a string passing! */
  105.     break;
  106.     }
  107.   }
  108.   scr->text=text;
  109.   scr->prg=prg;
  110.   return(FPLERR_MISSING_PARENTHESES);
  111. }
  112.  
  113. /**********************************************************************
  114.  *
  115.  * Getword()
  116.  *
  117.  * Store next word in a buffer. Returns error code!
  118.  *
  119.  *******/
  120.  
  121. ReturnCode REGARGS
  122. Getword(struct Data *scr)
  123. {
  124.   ReturnCode ret;
  125.   uchar len=0;
  126.   uchar *buffer = scr->buf;
  127.   if(ret=Eat(scr))
  128.     ;
  129.   else if(!isident(*scr->text))
  130.     ret=FPLERR_SYNTAX_ERROR; /* non-alpha char found where alpha is supposed */
  131.   else
  132.     do {
  133.       if(len<IDENTIFIER_LEN) {
  134.     /*
  135.      * With the length check above, we can use identifiers with
  136.      * _any_ length. There are only IDENTIFIER_LEN number of
  137.      * significant characters!
  138.      *
  139.      */
  140.     len++;
  141.     *buffer++=*scr->text++;
  142.       }
  143.     } while(isidentnum(*scr->text));
  144.   *buffer=0;
  145.   return(ret);
  146. }
  147.  
  148. /**********************************************************************
  149.  *
  150.  * int Eatcomment(struct Data *);
  151.  *
  152.  * Jumps to the end of the comment we're standing on.
  153.  *
  154.  *******/
  155.  
  156. static ReturnCode INLINE Eatcomment(struct Data *scr)
  157. {
  158.   ReturnCode ret;
  159.   long nums=0;
  160.   scr->text+=2;
  161.   while(scr->prg<=scr->prog->lines) {
  162.     switch(scr->text[0]) {
  163.     case CHAR_MULTIPLY:
  164.       if(scr->text[1]==CHAR_DIVIDE) {
  165.     scr->text+=2;
  166.         if(nums--)
  167.           break;
  168.     return(FPL_OK);
  169.       } else
  170.     scr->text++;
  171.       break;
  172.     case CHAR_ASCII_ZERO:
  173.       CALL(Newline(scr));
  174.       break;
  175.     case CHAR_NEWLINE:
  176.       scr->text++;
  177.       scr->virprg++; /* stepped down another virutal line! */
  178.       break;
  179.     case CHAR_DIVIDE:
  180.       if(scr->flags&FPLDATA_NESTED_COMMENTS && scr->text[1]==CHAR_MULTIPLY) {
  181.         nums++;
  182.         scr->text+=2;
  183.         break;
  184.       }
  185.     default:
  186.       scr->text++;
  187.       break;
  188.     }
  189.   }
  190.   return(FPLERR_UNBALANCED_COMMENT);
  191. }
  192.  
  193. /**********************************************************************
  194.  *
  195.  * int Eat(struct Data *);
  196.  *
  197.  * This eats all whitespaces, new lines and comments
  198.  *
  199.  * Returns error code.
  200.  *
  201.  *******/
  202.  
  203. ReturnCode REGARGS
  204. Eat(struct Data *scr)
  205. {
  206.   ReturnCode ret;
  207.   uchar new=0;
  208.   while(1) {
  209.     switch(*scr->text) {
  210.     case CHAR_NEWLINE:
  211.       scr->text++;
  212.       scr->virprg++; /* stepped down another virutal line! */
  213.       new=1;
  214.       break;
  215.     case CHAR_ASCII_ZERO:
  216.       CALL(Newline(scr));
  217.       /* This really confuses our virtual line counter! */
  218.       new=1;
  219.       break;
  220.     case CHAR_HASH:
  221.       if(new) {
  222.     /* This is the first 'real' character after a newline! That means
  223.        this could be a valid #line-instruction! */
  224.     scr->text++; /* pass the hash */
  225.     if(!Getword(scr)) {
  226.           /* there was a word following the hash sign! */
  227.  
  228.       if(!strcmp(scr->buf, "line")) {
  229.             /* 'line' instruction! */
  230.             scr->virprg=Strtol(scr->text, 10, &scr->text); /* get number */
  231.             Eat(scr); /* get whitespace */
  232.             if(*scr->text==CHAR_QUOTATION_MARK) {
  233.               /* we have a new virtual file name! */
  234.               scr->virfile=scr->text++; /* just point to this text! */
  235.               if(GetEnd(scr, CHAR_QUOTATION_MARK, 255, FALSE))
  236.                 return FPLERR_SYNTAX_ERROR;
  237.               Eat(scr);
  238.             }
  239.             break;
  240.           }
  241.       if(!strcmp(scr->buf, "pragma")) {
  242.             /* 'pragma' instruction! */
  243.             Getword(scr); /* get the following word */
  244.             if(!strcmp(scr->buf, "nocache")) {
  245.               /*
  246.                * The pragma 'nocache' marks this file to get flushed
  247.                * from memory as fast as not in use
  248.                */
  249.               scr->prog->flags |= PR_FLUSH_NOT_IN_USE;
  250.               break;
  251.             }
  252.             if(!strcmp(scr->buf, "cache")) {
  253.               /*
  254.                * The pragma 'cache' marks this file to *not* get flushed
  255.                * from memory when not in use
  256.                */
  257.               scr->prog->flags &= ~PR_FLUSH_NOT_IN_USE;
  258.               break;
  259.             }
  260.             if(!strcmp(scr->buf, "reread")) {
  261.               /*
  262.                * The pragma 'reread' marks this file to get reread into
  263.                * memory when accessed and the actual file is changed on disk
  264.                */
  265.               scr->prog->flags |= PR_REREAD_CHANGES;
  266.               break;
  267.             }
  268.             if(!strcmp(scr->buf, "noreread")) {
  269.               /*
  270.                * The pragma 'noreread' marks this file to *not* get reread
  271.                * into memory when accessed and the actual file is changed
  272.                * on disk
  273.                */
  274.               scr->prog->flags &= ~PR_REREAD_CHANGES;
  275.               break;
  276.             }
  277.             /* no supported pragma was found, eat the rest of the line as
  278.                usual in this case */
  279.           }
  280.       while (*++scr->text!=CHAR_NEWLINE);
  281.         }
  282. #ifdef UNIX
  283.     else if('!' == scr->text[0]) {
  284.       /* #! - styled line, skip the rest of it! */
  285.       while (*++scr->text!=CHAR_NEWLINE);
  286.     }
  287. #endif
  288.       } else
  289.     return(FPL_OK);
  290.       break;
  291.     case CHAR_DIVIDE:
  292.       if(scr->text[1]==CHAR_MULTIPLY) {
  293.     CALL(Eatcomment(scr));
  294.       } else if(scr->text[1]==CHAR_DIVIDE)
  295.     while (*++scr->text && *scr->text!=CHAR_NEWLINE);
  296.       else
  297.     return(FPL_OK);
  298.       new=0;
  299.       break;
  300.     default:
  301.       if(!isspace(*scr->text))
  302.     return(FPL_OK);
  303.       scr->text++;
  304.       new=0;
  305.       break;
  306.     }
  307.   }
  308. }
  309.  
  310. /*********************************************************************
  311.  *
  312.  * Newline()
  313.  *
  314.  * This routine gets called everytime the interpreter finds an ASCII
  315.  * zero in the program. This is made like this for future version which
  316.  * will be able to specify programs in several ways. (Not only the
  317.  * array and continues memory alternatives!)
  318.  *
  319.  *****/
  320.  
  321. ReturnCode REGARGS
  322. Newline(struct Data *scr)
  323. {
  324.   if(scr->prg<scr->prog->lines) {
  325.     scr->text=(&scr->prog->program)[scr->prg++];
  326.     return(FPL_OK);
  327.   } else
  328.     return(FPLERR_UNEXPECTED_END);
  329. }
  330.  
  331.  
  332. ReturnCode REGARGS ScanForNext(struct Data *scr,
  333.                                Operator op) /* previous operator */
  334. {
  335.   long val=0;
  336.   long junk;
  337.   ReturnCode ret;
  338.   while( !( ret = Eat(scr) ) ) {
  339.     if(ispunct(scr->text[0])) {
  340.       switch(scr->text[0]) {
  341.       case CHAR_OPEN_PAREN:
  342.     CALL(GetEnd(scr, CHAR_CLOSE_PAREN, CHAR_OPEN_PAREN, TRUE));
  343.     continue;
  344.       case CHAR_OPEN_BRACKET:
  345.     if(GetEnd(scr, CHAR_CLOSE_BRACKET, CHAR_OPEN_BRACKET, TRUE))
  346.           return FPLERR_MISSING_BRACKET;
  347.     continue;
  348.       case CHAR_SEMICOLON:
  349.       case CHAR_CLOSE_PAREN:
  350.       case CHAR_CLOSE_BRACKET:
  351.  
  352.       case CHAR_OPEN_BRACE:  /* these two are very wrong if they appear! */
  353.       case CHAR_CLOSE_BRACE:
  354.  
  355.     /* done, return to base */
  356.     return FPL_OK;
  357.     break;
  358.       case CHAR_QUOTATION_MARK:
  359.     if(GetEnd(scr, CHAR_QUOTATION_MARK, 255, FALSE))
  360.           return FPLERR_SYNTAX_ERROR;
  361.     break;
  362.       case CHAR_AND:
  363.     break;
  364.       case CHAR_OR:
  365.     if(CHAR_OR == scr->text[1]) {
  366.       if(OP_LOGAND == op) {
  367.         /* we have to stop here! */
  368.         return FPL_OK;
  369.       }
  370.     }
  371.     break;
  372.       case CHAR_APOSTROPHE:
  373.     /*
  374.      * Eat this properly!!!
  375.      */
  376.     scr->text++;
  377.     CALL(ReturnChar(scr, &junk, FALSE));
  378.     if(CHAR_APOSTROPHE!=*scr->text++)
  379.       return(FPLERR_MISSING_APOSTROPHE);
  380.     continue;
  381.       case CHAR_QUESTION:
  382.     if(OP_LOGAND == op ||
  383.        OP_LOGOR == op)
  384.       return FPL_OK;
  385.     if(OP_COND1 == op)
  386.       val++;    /* remember there was an extra '?' !! */
  387.     break;
  388.       case CHAR_COLON:
  389.     if(OP_COND1 == op) {
  390.       if(!val--)    /* don't forget if there were any extra '?' !! */
  391.         return FPL_OK;
  392.     }
  393.     break;
  394.       case CHAR_COMMA:
  395.     return FPL_OK;
  396.       }
  397.       scr->text++;
  398.     }
  399.     else {
  400.       while(!ispunct(*scr->text))
  401.     scr->text++;
  402.     }
  403.   }
  404. }
  405.